home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / impacket / dcerpc / winreg.pyc (.txt) < prev   
Python Compiled Bytecode  |  2006-06-30  |  27KB  |  822 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import array
  5. import struct
  6. import dcerpc
  7. from impacket import ImpactPacket
  8. MSRPC_UUID_WINREG = '\x01\xd0\x8c3D"\xf11\xaa\xaa\x90\x008\x00\x10\x03\x01\x00\x00\x00'
  9. KEY_CREATE_LINK = 32
  10. KEY_CREATE_SUB_KEY = 4
  11. KEY_ENUMERATE_SUB_KEYS = 8
  12. KEY_EXECUTE = 131097
  13. KEY_NOTIFY = 16
  14. KEY_QUERY_VALUE = 1
  15. KEY_SET_VALUE = 2
  16. KEY_ALL_ACCESS = 983103
  17. KEY_READ = 131097
  18. KEY_WRITE = 131078
  19. REG_NONE = 0
  20. REG_SZ = 1
  21. REG_EXPAND_SZ = 2
  22. REG_BINARY = 3
  23. REG_DWORD = 4
  24. REG_DWORD_LITTLE_ENDIAN = 4
  25. REG_DWORD_BIG_ENDIAN = 5
  26. REG_LINK = 6
  27. REG_MULTI_SZ = 7
  28. REG_RESOURCE_LIST = 8
  29. REG_FULL_RESOURCE_DESCRIPTOR = 9
  30. REG_RESOURCE_REQUIREMENTS_LIST = 10
  31.  
  32. class WINREGCloseKey(ImpactPacket.Header):
  33.     OP_NUM = 5
  34.     __SIZE = 20
  35.     
  36.     def __init__(self, aBuffer = None):
  37.         ImpactPacket.Header.__init__(self, WINREGCloseKey._WINREGCloseKey__SIZE)
  38.         if aBuffer:
  39.             self.load_header(aBuffer)
  40.         
  41.  
  42.     
  43.     def get_context_handle(self):
  44.         return self.get_bytes().tolist()[:20]
  45.  
  46.     
  47.     def set_context_handle(self, handle):
  48.         if not 20 == len(handle):
  49.             raise AssertionError
  50.         self.get_bytes()[:20] = array.array('B', handle)
  51.  
  52.     
  53.     def get_header_size(self):
  54.         return WINREGCloseKey._WINREGCloseKey__SIZE
  55.  
  56.  
  57.  
  58. class WINREGRespCloseKey(ImpactPacket.Header):
  59.     __SIZE = 24
  60.     
  61.     def __init__(self, aBuffer = None):
  62.         ImpactPacket.Header.__init__(self, WINREGRespCloseKey._WINREGRespCloseKey__SIZE)
  63.         if aBuffer:
  64.             self.load_header(aBuffer)
  65.         
  66.  
  67.     
  68.     def get_context_handle(self):
  69.         return self.get_bytes().tolist()[:20]
  70.  
  71.     
  72.     def set_context_handle(self, handle):
  73.         if not 20 == len(handle):
  74.             raise AssertionError
  75.         self.get_bytes()[:20] = array.array('B', handle)
  76.  
  77.     
  78.     def get_return_code(self):
  79.         return self.get_long(20, '<')
  80.  
  81.     
  82.     def set_return_code(self, code):
  83.         self.set_long(20, code, '<')
  84.  
  85.     
  86.     def get_header_size(self):
  87.         return WINREGRespCloseKey._WINREGRespCloseKey__SIZE
  88.  
  89.  
  90.  
  91. class WINREGDeleteValue(ImpactPacket.Header):
  92.     OP_NUM = 8
  93.     __SIZE = 40
  94.     
  95.     def __init__(self, aBuffer = None):
  96.         ImpactPacket.Header.__init__(self, WINREGDeleteValue._WINREGDeleteValue__SIZE)
  97.         self.get_bytes()[22:36] = array.array('B', '\n\x02\x00\xec\xfd\x7f\x05\x01' + 6 * '\x00')
  98.         if aBuffer:
  99.             self.load_header(aBuffer)
  100.         
  101.  
  102.     
  103.     def get_context_handle(self):
  104.         return self.get_bytes().tolist()[:20]
  105.  
  106.     
  107.     def set_context_handle(self, handle):
  108.         if not 20 == len(handle):
  109.             raise AssertionError
  110.         self.get_bytes()[:20] = array.array('B', handle)
  111.  
  112.     
  113.     def get_name(self):
  114.         return unicode(self.get_bytes().tostring()[40:], 'utf-16le')
  115.  
  116.     
  117.     def set_name(self, name):
  118.         if not name.endswith('\x00'):
  119.             name += '\x00'
  120.         
  121.         namelen = len(name)
  122.         wlen = 2 * namelen
  123.         if wlen % 4:
  124.             pad = '\x00' * (4 - wlen % 4)
  125.         else:
  126.             pad = ''
  127.         self.set_word(20, 2 * namelen, '<')
  128.         self.set_long(36, namelen, '<')
  129.         self.get_bytes()[40:] = array.array('B', name.encode('utf-16le') + pad)
  130.  
  131.     
  132.     def get_header_size(self):
  133.         var_size = len(self.get_bytes()) - WINREGDeleteValue._WINREGDeleteValue__SIZE
  134.         if not var_size > 0:
  135.             raise AssertionError
  136.         return WINREGDeleteValue._WINREGDeleteValue__SIZE + var_size
  137.  
  138.  
  139.  
  140. class WINREGRespDeleteValue(ImpactPacket.Header):
  141.     __SIZE = 4
  142.     
  143.     def __init__(self, aBuffer = None):
  144.         ImpactPacket.Header.__init__(self, WINREGRespDeleteValue._WINREGRespDeleteValue__SIZE)
  145.         if aBuffer:
  146.             self.load_header(aBuffer)
  147.         
  148.  
  149.     
  150.     def get_return_code(self):
  151.         return self.get_long(0, '<')
  152.  
  153.     
  154.     def set_return_code(self, code):
  155.         self.set_long(0, code, '<')
  156.  
  157.     
  158.     def get_header_size(self):
  159.         return WINREGRespDeleteValue._WINREGRespDeleteValue__SIZE
  160.  
  161.  
  162.  
  163. class WINREGDeleteKey(ImpactPacket.Header):
  164.     OP_NUM = 7
  165.     __SIZE = 40
  166.     
  167.     def __init__(self, aBuffer = None):
  168.         ImpactPacket.Header.__init__(self, WINREGDeleteKey._WINREGDeleteKey__SIZE)
  169.         self.get_bytes()[22:36] = array.array('B', '\n\x02\x00\xec\xfd\x7f\x05\x01' + 6 * '\x00')
  170.         if aBuffer:
  171.             self.load_header(aBuffer)
  172.         
  173.  
  174.     
  175.     def get_context_handle(self):
  176.         return self.get_bytes().tolist()[:20]
  177.  
  178.     
  179.     def set_context_handle(self, handle):
  180.         if not 20 == len(handle):
  181.             raise AssertionError
  182.         self.get_bytes()[:20] = array.array('B', handle)
  183.  
  184.     
  185.     def get_key_name(self):
  186.         return unicode(self.get_bytes().tostring()[40:], 'utf-16le')
  187.  
  188.     
  189.     def set_key_name(self, name):
  190.         if not name.endswith('\x00'):
  191.             name += '\x00'
  192.         
  193.         namelen = len(name)
  194.         wlen = 2 * namelen
  195.         if wlen % 4:
  196.             pad = '\x00' * (4 - wlen % 4)
  197.         else:
  198.             pad = ''
  199.         self.set_word(20, 2 * namelen, '<')
  200.         self.set_long(36, namelen, '<')
  201.         self.get_bytes()[40:] = array.array('B', name.encode('utf-16le') + pad)
  202.  
  203.     
  204.     def get_header_size(self):
  205.         var_size = len(self.get_bytes()) - WINREGDeleteKey._WINREGDeleteKey__SIZE
  206.         if not var_size > 0:
  207.             raise AssertionError
  208.         return WINREGDeleteKey._WINREGDeleteKey__SIZE + var_size
  209.  
  210.  
  211.  
  212. class WINREGRespDeleteKey(ImpactPacket.Header):
  213.     __SIZE = 4
  214.     
  215.     def __init__(self, aBuffer = None):
  216.         ImpactPacket.Header.__init__(self, WINREGRespDeleteKey._WINREGRespDeleteKey__SIZE)
  217.         if aBuffer:
  218.             self.load_header(aBuffer)
  219.         
  220.  
  221.     
  222.     def get_return_code(self):
  223.         return self.get_long(0, '<')
  224.  
  225.     
  226.     def set_return_code(self, code):
  227.         self.set_long(0, code, '<')
  228.  
  229.     
  230.     def get_header_size(self):
  231.         return WINREGRespDeleteKey._WINREGRespDeleteKey__SIZE
  232.  
  233.  
  234.  
  235. class WINREGCreateKey(ImpactPacket.Header):
  236.     OP_NUM = 6
  237.     __SIZE = 64
  238.     
  239.     def __init__(self, aBuffer = None):
  240.         ImpactPacket.Header.__init__(self, WINREGCreateKey._WINREGCreateKey__SIZE)
  241.         self.get_bytes()[22:36] = array.array('B', '\n\x02\x00\xec\xfd\x7f\x05\x01' + 6 * '\x00')
  242.         self.get_bytes()[-24:] = array.array('B', 15 * '\x00' + '\x02' + 8 * '\x00')
  243.         if aBuffer:
  244.             self.load_header(aBuffer)
  245.         
  246.  
  247.     
  248.     def get_context_handle(self):
  249.         return self.get_bytes().tolist()[:20]
  250.  
  251.     
  252.     def set_context_handle(self, handle):
  253.         if not 20 == len(handle):
  254.             raise AssertionError
  255.         self.get_bytes()[:20] = array.array('B', handle)
  256.  
  257.     
  258.     def get_key_name(self):
  259.         return unicode(self.get_bytes().tostring()[40:-24], 'utf-16le')
  260.  
  261.     
  262.     def set_key_name(self, name):
  263.         if not name.endswith('\x00'):
  264.             name += '\x00'
  265.         
  266.         namelen = len(name)
  267.         wlen = 2 * namelen
  268.         if wlen % 4:
  269.             pad = '\x00' * (4 - wlen % 4)
  270.         else:
  271.             pad = ''
  272.         self.set_word(20, 2 * namelen, '<')
  273.         self.set_long(36, namelen, '<')
  274.         self.get_bytes()[40:-24] = array.array('B', name.encode('utf-16le') + pad)
  275.  
  276.     
  277.     def get_header_size(self):
  278.         var_size = len(self.get_bytes()) - WINREGCreateKey._WINREGCreateKey__SIZE
  279.         if not var_size > 0:
  280.             raise AssertionError
  281.         return WINREGCreateKey._WINREGCreateKey__SIZE + var_size
  282.  
  283.  
  284.  
  285. class WINREGRespCreateKey(ImpactPacket.Header):
  286.     __SIZE = 28
  287.     
  288.     def __init__(self, aBuffer = None):
  289.         ImpactPacket.Header.__init__(self, WINREGRespCreateKey._WINREGRespCreateKey__SIZE)
  290.         if aBuffer:
  291.             self.load_header(aBuffer)
  292.         
  293.  
  294.     
  295.     def get_context_handle(self):
  296.         return self.get_bytes().tolist()[:20]
  297.  
  298.     
  299.     def set_context_handle(self, handle):
  300.         if not 20 == len(handle):
  301.             raise AssertionError
  302.         self.get_bytes()[:20] = array.array('B', handle)
  303.  
  304.     
  305.     def get_return_code(self):
  306.         return self.get_long(24, '<')
  307.  
  308.     
  309.     def set_return_code(self, code):
  310.         self.set_long(24, code, '<')
  311.  
  312.     
  313.     def get_header_size(self):
  314.         return WINREGRespCreateKey._WINREGRespCreateKey__SIZE
  315.  
  316.  
  317.  
  318. class WINREGOpenKey(ImpactPacket.Header):
  319.     OP_NUM = 15
  320.     __SIZE = 44
  321.     
  322.     def __init__(self, aBuffer = None):
  323.         ImpactPacket.Header.__init__(self, WINREGOpenKey._WINREGOpenKey__SIZE)
  324.         self.set_access_mask(KEY_READ)
  325.         self.get_bytes()[24:28] = array.array('B', '\x00\xec\xfd\x7f')
  326.         if aBuffer:
  327.             self.load_header(aBuffer)
  328.         
  329.  
  330.     
  331.     def get_context_handle(self):
  332.         return self.get_bytes().tolist()[:20]
  333.  
  334.     
  335.     def set_context_handle(self, handle):
  336.         if not 20 == len(handle):
  337.             raise AssertionError
  338.         self.get_bytes()[:20] = array.array('B', handle)
  339.  
  340.     
  341.     def get_key_name(self):
  342.         return unicode(self.get_bytes().tostring()[40:-4], 'utf-16le')
  343.  
  344.     
  345.     def set_key_name(self, name):
  346.         if not name.endswith('\x00'):
  347.             name += '\x00'
  348.         
  349.         namelen = len(name)
  350.         padlen = 2 * (int((namelen + 2) / 4) * 4 + 2 - namelen)
  351.         pad = '\x00' * padlen
  352.         self.set_word(20, 2 * namelen, '<')
  353.         self.set_word(22, 2 * namelen, '<')
  354.         self.set_long(28, namelen, '<')
  355.         self.set_long(36, namelen, '<')
  356.         self.get_bytes()[40:-4] = array.array('B', name.encode('utf-16le') + pad)
  357.  
  358.     
  359.     def get_access_mask(self):
  360.         return self.get_long(-4, '<')
  361.  
  362.     
  363.     def set_access_mask(self, mask):
  364.         self.set_long(-4, mask, '<')
  365.  
  366.     
  367.     def get_header_size(self):
  368.         var_size = len(self.get_bytes()) - WINREGOpenKey._WINREGOpenKey__SIZE
  369.         if not var_size > 0:
  370.             raise AssertionError
  371.         return WINREGOpenKey._WINREGOpenKey__SIZE + var_size
  372.  
  373.  
  374.  
  375. class WINREGRespOpenKey(ImpactPacket.Header):
  376.     __SIZE = 24
  377.     
  378.     def __init__(self, aBuffer = None):
  379.         ImpactPacket.Header.__init__(self, WINREGRespOpenKey._WINREGRespOpenKey__SIZE)
  380.         if aBuffer:
  381.             self.load_header(aBuffer)
  382.         
  383.  
  384.     
  385.     def get_context_handle(self):
  386.         return self.get_bytes().tolist()[:20]
  387.  
  388.     
  389.     def set_context_handle(self, handle):
  390.         if not 20 == len(handle):
  391.             raise AssertionError
  392.         self.get_bytes()[:20] = array.array('B', handle)
  393.  
  394.     
  395.     def get_return_code(self):
  396.         return self.get_long(20, '<')
  397.  
  398.     
  399.     def set_return_code(self, code):
  400.         self.set_long(20, code, '<')
  401.  
  402.     
  403.     def get_header_size(self):
  404.         return WINREGRespOpenKey._WINREGRespOpenKey__SIZE
  405.  
  406.  
  407.  
  408. class WINREGSetValue(ImpactPacket.Header):
  409.     OP_NUM = 22
  410.     __SIZE = 52
  411.     
  412.     def __init__(self, aBuffer = None):
  413.         ImpactPacket.Header.__init__(self, WINREGSetValue._WINREGSetValue__SIZE)
  414.         self.get_bytes()[24:28] = array.array('B', '\x00\xec\xfd\x7f')
  415.         self.namelen = 0
  416.         if aBuffer:
  417.             self.load_header(aBuffer)
  418.         
  419.  
  420.     
  421.     def get_context_handle(self):
  422.         return self.get_bytes().tolist()[:20]
  423.  
  424.     
  425.     def set_context_handle(self, handle):
  426.         if not 20 == len(handle):
  427.             raise AssertionError
  428.         self.get_bytes()[:20] = array.array('B', handle)
  429.  
  430.     
  431.     def get_name(self):
  432.         return unicode(self.get_bytes().tostring()[40:40 + self.namelen], 'utf-16le')
  433.  
  434.     
  435.     def set_name(self, name):
  436.         if not name.endswith('\x00'):
  437.             name += '\x00'
  438.         
  439.         namelen = len(name)
  440.         if namelen & 1:
  441.             pad = '\x00\x00'
  442.         else:
  443.             pad = ''
  444.         self.set_word(20, 2 * namelen, '<')
  445.         self.set_word(22, 2 * namelen, '<')
  446.         self.set_long(28, namelen, '<')
  447.         self.set_long(36, namelen, '<')
  448.         padded_name = array.array('B', name.encode('utf-16le') + pad)
  449.         self.get_bytes()[40:40 + self.namelen] = padded_name
  450.         self.namelen = len(padded_name)
  451.  
  452.     
  453.     def get_data_type(self):
  454.         return self.get_long(40 + self.namelen, '<')
  455.  
  456.     
  457.     def set_data_type(self, type):
  458.         self.set_long(40 + self.namelen, type, '<')
  459.  
  460.     
  461.     def get_data(self):
  462.         data_type = self.get_data_type()
  463.         data = self.get_bytes().tostring()[40 + self.namelen + 8:-4]
  464.         if data_type == REG_DWORD:
  465.             data = struct.unpack('<L', data)[0]
  466.         elif data_type == REG_SZ:
  467.             data = unicode(data, 'utf-16le')
  468.         
  469.         return data
  470.  
  471.     
  472.     def set_data(self, data):
  473.         data_type = self.get_data_type()
  474.         pad = ''
  475.         if data_type == REG_DWORD:
  476.             data = struct.pack('<L', data)
  477.         elif data_type == REG_SZ:
  478.             if not data.endswith('\x00'):
  479.                 data += '\x00'
  480.             
  481.             if len(data) & 1:
  482.                 pad = '\x00\x00'
  483.             
  484.             data = data.encode('utf-16le')
  485.         elif data_type == REG_BINARY:
  486.             if len(data) & 1:
  487.                 pad = '\x00\x00'
  488.             
  489.         
  490.         datalen = len(data)
  491.         self.set_long(40 + self.namelen + 4, datalen, '<')
  492.         self.set_long(-4, datalen, '<')
  493.         self.get_bytes()[40 + self.namelen + 8:-4] = array.array('B', data + pad)
  494.  
  495.     
  496.     def get_header_size(self):
  497.         var_size = len(self.get_bytes()) - WINREGSetValue._WINREGSetValue__SIZE
  498.         if not var_size > 0:
  499.             raise AssertionError
  500.         return WINREGSetValue._WINREGSetValue__SIZE + var_size
  501.  
  502.  
  503.  
  504. class WINREGRespSetValue(ImpactPacket.Header):
  505.     __SIZE = 4
  506.     
  507.     def __init__(self, aBuffer = None):
  508.         ImpactPacket.Header.__init__(self, WINREGRespSetValue._WINREGRespSetValue__SIZE)
  509.         if aBuffer:
  510.             self.load_header(aBuffer)
  511.         
  512.  
  513.     
  514.     def get_return_code(self):
  515.         return self.get_long(0, '<')
  516.  
  517.     
  518.     def set_return_code(self, code):
  519.         self.set_long(0, code, '<')
  520.  
  521.     
  522.     def get_header_size(self):
  523.         return WINREGRespSetValue._WINREGRespSetValue__SIZE
  524.  
  525.  
  526.  
  527. class WINREGQueryValue(ImpactPacket.Header):
  528.     OP_NUM = 17
  529.     __SIZE = 80
  530.     
  531.     def __init__(self, aBuffer = None):
  532.         ImpactPacket.Header.__init__(self, WINREGQueryValue._WINREGQueryValue__SIZE)
  533.         self.set_data_len(200)
  534.         self.get_bytes()[24:28] = array.array('B', '\x00\xec\xfd\x7f')
  535.         self.get_bytes()[-40:-28] = array.array('B', '\x8c\xfe\x12\x00iE\x13\x00iE\x13\x00')
  536.         self.get_bytes()[-16:-12] = array.array('B', '\x94\xfe\x12\x00')
  537.         self.get_bytes()[-8:-4] = array.array('B', '\x80\xfe\x12\x00')
  538.         if aBuffer:
  539.             self.load_header(aBuffer)
  540.         
  541.  
  542.     
  543.     def get_context_handle(self):
  544.         return self.get_bytes().tolist()[:20]
  545.  
  546.     
  547.     def set_context_handle(self, handle):
  548.         if not 20 == len(handle):
  549.             raise AssertionError
  550.         self.get_bytes()[:20] = array.array('B', handle)
  551.  
  552.     
  553.     def get_name(self):
  554.         return unicode(self.get_bytes().tostring()[40:-40], 'utf-16le')
  555.  
  556.     
  557.     def set_name(self, name):
  558.         if not name.endswith('\x00'):
  559.             name += '\x00'
  560.         
  561.         namelen = len(name)
  562.         if namelen & 1:
  563.             pad = '\x00\x00'
  564.         else:
  565.             pad = ''
  566.         self.set_word(20, 2 * namelen, '<')
  567.         self.set_word(22, 2 * namelen, '<')
  568.         self.set_long(28, namelen, '<')
  569.         self.set_long(36, namelen, '<')
  570.         self.get_bytes()[40:-40] = array.array('B', name.encode('utf-16le') + pad)
  571.  
  572.     
  573.     def get_data_len(self):
  574.         return self.get_long(-28, '<')
  575.  
  576.     
  577.     def set_data_len(self, len):
  578.         self.set_long(-28, len, '<')
  579.         self.set_long(-12, len, '<')
  580.  
  581.     
  582.     def get_header_size(self):
  583.         var_size = len(self.get_bytes()) - WINREGQueryValue._WINREGQueryValue__SIZE
  584.         if not var_size > 0:
  585.             raise AssertionError
  586.         return WINREGQueryValue._WINREGQueryValue__SIZE + var_size
  587.  
  588.  
  589.  
  590. class WINREGRespQueryValue(ImpactPacket.Header):
  591.     __SIZE = 44
  592.     
  593.     def __init__(self, aBuffer = None):
  594.         ImpactPacket.Header.__init__(self, WINREGRespQueryValue._WINREGRespQueryValue__SIZE)
  595.         if aBuffer:
  596.             self.load_header(aBuffer)
  597.         
  598.  
  599.     
  600.     def get_data_type(self):
  601.         return self.get_long(4, '<')
  602.  
  603.     
  604.     def set_data_type(self, type):
  605.         self.set_long(4, type, '<')
  606.  
  607.     
  608.     def get_data_len(self):
  609.         return self.get_long(20, '<')
  610.  
  611.     
  612.     def set_data_len(self, len):
  613.         self.set_long(20, len, '<')
  614.         self.set_long(28, len, '<')
  615.  
  616.     
  617.     def get_data(self):
  618.         data_type = self.get_data_type()
  619.         data = self.get_bytes().tostring()[24:24 + self.get_data_len()]
  620.         if data_type == REG_DWORD:
  621.             data = struct.unpack('<L', data)[0]
  622.         elif data_type == REG_SZ:
  623.             data = unicode(data, 'utf-16le')
  624.         
  625.         return data
  626.  
  627.     
  628.     def set_data(self, len):
  629.         raise Exception, 'method not implemented'
  630.  
  631.     
  632.     def get_return_code(self):
  633.         return self.get_long(-4, '<')
  634.  
  635.     
  636.     def set_return_code(self, code):
  637.         self.set_long(-4, code, '<')
  638.  
  639.     
  640.     def get_header_size(self):
  641.         var_size = len(self.get_bytes()) - WINREGRespQueryValue._WINREGRespQueryValue__SIZE
  642.         if not var_size > 0:
  643.             raise AssertionError
  644.         return WINREGRespQueryValue._WINREGRespQueryValue__SIZE + var_size
  645.  
  646.  
  647.  
  648. class WINREGOpenHK(ImpactPacket.Header):
  649.     __SIZE = 12
  650.     
  651.     def __init__(self, aBuffer = None):
  652.         ImpactPacket.Header.__init__(self, WINREGOpenHK._WINREGOpenHK__SIZE)
  653.         self.set_long(0, 456640, '<')
  654.         self.set_long(4, 105304, '<')
  655.         self.set_access_mask(33554432)
  656.         if aBuffer:
  657.             self.load_header(aBuffer)
  658.         
  659.  
  660.     
  661.     def get_access_mask(self):
  662.         return self.get_long(8, '<')
  663.  
  664.     
  665.     def set_access_mask(self, mask):
  666.         self.set_long(8, mask, '<')
  667.  
  668.     
  669.     def get_header_size(self):
  670.         return WINREGOpenHK._WINREGOpenHK__SIZE
  671.  
  672.  
  673.  
  674. class WINREGRespOpenHK(ImpactPacket.Header):
  675.     __SIZE = 24
  676.     
  677.     def __init__(self, aBuffer = None):
  678.         ImpactPacket.Header.__init__(self, WINREGRespOpenHK._WINREGRespOpenHK__SIZE)
  679.         if aBuffer:
  680.             self.load_header(aBuffer)
  681.         
  682.  
  683.     
  684.     def get_context_handle(self):
  685.         return self.get_bytes().tolist()[:20]
  686.  
  687.     
  688.     def set_context_handle(self, handle):
  689.         if not 20 == len(handle):
  690.             raise AssertionError
  691.         self.get_bytes()[:20] = array.array('B', handle)
  692.  
  693.     
  694.     def get_return_code(self):
  695.         return self.get_long(20, '<')
  696.  
  697.     
  698.     def set_return_code(self, code):
  699.         self.set_long(20, code, '<')
  700.  
  701.     
  702.     def get_header_size(self):
  703.         return WINREGRespOpenHK._WINREGRespOpenHK__SIZE
  704.  
  705.  
  706.  
  707. class WINREGOpenHKCR(WINREGOpenHK):
  708.     OP_NUM = 0
  709.  
  710.  
  711. class WINREGOpenHKLM(WINREGOpenHK):
  712.     OP_NUM = 2
  713.  
  714.  
  715. class WINREGOpenHKU(WINREGOpenHK):
  716.     OP_NUM = 4
  717.  
  718.  
  719. class DCERPCWinReg:
  720.     
  721.     def __init__(self, dce):
  722.         self._dce = dce
  723.  
  724.     
  725.     def openHKCR(self):
  726.         winregopen = WINREGOpenHKCR()
  727.         self._dce.send(winregopen)
  728.         data = self._dce.recv()
  729.         retVal = WINREGRespOpenHK(data)
  730.         return retVal
  731.  
  732.     
  733.     def openHKU(self):
  734.         winregopen = WINREGOpenHKU()
  735.         self._dce.send(winregopen)
  736.         data = self._dce.recv()
  737.         retVal = WINREGRespOpenHK(data)
  738.         return retVal
  739.  
  740.     
  741.     def regCloseKey(self, context_handle):
  742.         wreg_closekey = WINREGCloseKey()
  743.         wreg_closekey.set_context_handle(context_handle)
  744.         self._dce.send(wreg_closekey)
  745.         data = self._dce.recv()
  746.         retVal = WINREGRespCloseKey(data)
  747.         return retVal
  748.  
  749.     
  750.     def regOpenKey(self, context_handle, aKeyname, anAccessMask):
  751.         wreg_openkey = WINREGOpenKey()
  752.         wreg_openkey.set_context_handle(context_handle)
  753.         wreg_openkey.set_key_name(aKeyname)
  754.         wreg_openkey.set_access_mask(anAccessMask)
  755.         self._dce.send(wreg_openkey)
  756.         data = self._dce.recv()
  757.         retVal = WINREGRespOpenKey(data)
  758.         return retVal
  759.  
  760.     
  761.     def regCreateKey(self, context_handle, aKeyname):
  762.         wreg_createkey = WINREGCreateKey()
  763.         wreg_createkey.set_context_handle(context_handle)
  764.         wreg_createkey.set_key_name(aKeyname)
  765.         self._dce.send(wreg_createkey)
  766.         data = self._dce.recv()
  767.         retVal = WINREGRespCreateKey(data)
  768.         return retVal
  769.  
  770.     
  771.     def regDeleteKey(self, context_handle, aKeyname):
  772.         wreg_deletekey = WINREGDeleteKey()
  773.         wreg_deletekey.set_context_handle(context_handle)
  774.         wreg_deletekey.set_key_name(aKeyname)
  775.         self._dce.send(wreg_deletekey)
  776.         data = self._dce.recv()
  777.         retVal = WINREGRespDeleteKey(data)
  778.         return retVal
  779.  
  780.     
  781.     def regDeleteValue(self, context_handle, aValuename):
  782.         wreg_deletevalue = WINREGDeleteValue()
  783.         wreg_deletevalue.set_context_handle(context_handle)
  784.         wreg_deletevalue.set_name(aValuename)
  785.         self._dce.send(wreg_deletevalue)
  786.         data = self._dce.recv()
  787.         retVal = WINREGRespDeleteValue(data)
  788.         return retVal
  789.  
  790.     
  791.     def regQueryValue(self, context_handle, aValueName, aDataLen):
  792.         wreg_queryval = WINREGQueryValue()
  793.         wreg_queryval.set_context_handle(context_handle)
  794.         wreg_queryval.set_name(aValueName)
  795.         wreg_queryval.set_data_len(aDataLen)
  796.         self._dce.send(wreg_queryval)
  797.         data = self._dce.recv()
  798.         retVal = WINREGRespQueryValue(data)
  799.         return retVal
  800.  
  801.     
  802.     def regSetValue(self, context_handle, aValueType, aValueName, aData):
  803.         wreg_setval = WINREGSetValue()
  804.         wreg_setval.set_context_handle(context_handle)
  805.         wreg_setval.set_data_type(aValueType)
  806.         wreg_setval.set_name(aValueName)
  807.         wreg_setval.set_data(aData)
  808.         self._dce.send(wreg_setval)
  809.         data = self._dce.recv()
  810.         retVal = WINREGRespSetValue(data)
  811.         return retVal
  812.  
  813.     
  814.     def openHKLM(self):
  815.         winregopen = WINREGOpenHKLM()
  816.         self._dce.send(winregopen)
  817.         data = self._dce.recv()
  818.         retVal = WINREGRespOpenHK(data)
  819.         return retVal
  820.  
  821.  
  822.